Instance 0

Class410.readContent(InputStream stream,String charset)#2{
      int n = reader.read(readBuffer);
      while (n > 0)
      {
        buffer.append(readBuffer, 0, n);
        n = reader.read(readBuffer);
      }
}


Instance 1

Class650.extractReaderContents(BufferedReader bufferedReader)#0{
      int readCharacterCount = bufferedReader.read(readInCharacters);
      while (readCharacterCount > -1) {
        contents.append(String.valueOf(readInCharacters));
        readCharacterCount = bufferedReader.read(readInCharacters);
      }
      bufferedReader.close();
}


Instance 2

Class590.getText(InputStream stream,String charset)#0{
        int numRead = reader.read(chars);
        while (numRead != -1)
        {
          sw.write(chars, 0, numRead);
          numRead = reader.read(chars);
        }
        reader.close();
}


Instance 3

Class560.loadPlotData(TownBlock townBlock)#0{
            plotBlockData.setVersion(version);
            plotBlockData.setHeight(fin.read());
          while ((value = fin.read()) >= 0) {
            IntArr.add(value);  
          }
}


Instance 4

Class530.rewriteHeader()#1{
        while ((line = br.readLine()) != null) {
            if (descriptionLinePattern.matcher(line).matches()) {
                wr.write("DESCRIPTION \"");
                wr.write(description);
                wr.write("\"\n");
                descriptionWritten = true;
            } else if(platformLinePattern.matcher(line).matches()) {
                wr.write("PLATFORM ");
                wr.write(platform);
                wr.write("\n");
                platformWritten = true;
            } else if(line.startsWith("(")) {
                if(!descriptionWritten) {
                    wr.write("DESCRIPTION \"");
                    wr.write(description);
                    wr.write("\"\n");
                }

                if(!platformWritten) {
                    wr.write("PLATFORM ");
                    wr.write(platform);
                    wr.write("\n");
                }

                wr.write(line);
                wr.append('\n');
                break;
            /* Write all other lines */
            } else {
                wr.write(line);
                wr.append('\n');
            }
        }
        while ((len = br.read(buff, 0, 4096)) > 0) {
            wr.write(buff, 0, len);
        }
        wr.close();
}


Instance 5

Class90.readFile(String fileName,boolean showExceptions)#0{
      inFile = reader(fileName, false, showExceptions);
      if (inFile == null) return "";
      while ((len = inFile.read(buff)) >= 0)
        strb.append(buff, 0, len);
      inFile.close();
}


Instance 6

Class60.read(BufferedReader requestReader,HttpServletRequest req)#0{
        while (-1 != (c = requestReader.read())) {
            output.append((char) c);
        }
        requestReader.close();
}


Instance 7

Class130.readFrom(Class arg0,Type arg1,Annotation[] arg2,MediaType arg3,MultivaluedMap arg4,InputStream is)#2{
        while ((ch = br.read()) > -1) {
            sb.append((char) ch);
        }
        br.close();
}


Instance 8

Class80.getFileContents(InputStream in)#0{
      while ((read= br.read()) != -1)
        sb.append((char) read);
      br.close();
}


Instance 9

Class520.runConsole(String sCmd)#0{
        while ((read = reader.read(buffer)) > 0) {
            output.append(buffer, 0, read);
        }
        reader.close();
}


Instance 10

Class130.getContents(InputStream in)#1{
            while ((read= br.read()) != -1)
                sb.append((char) read);
            br.close();
}


Instance 11

Class150.exec(String command)#5{
            while ((read = reader.read(buffer)) > 0) {
                output.append(buffer, 0, read);
            }
            reader.close();
}


Instance 12

Class210.doHttpCall(String methodName,String marshaledData)#2{
        while ((ch = br.read()) > -1) {
            sb.append((char) ch);
        }
        br.close();
}


Instance 13

Class180.parse(String rulename,File file,boolean trace)#2{
    while ((ch = in.read()) != -1)
      out.append((char)ch);
    in.close();
}


Instance 14

Class230.getContents(IStorage file)#3{
            while ((read= br.read()) != -1)
                sb.append((char) read);
            br.close();
}


Instance 15

Class370.getFileAsString(File file,String charEncoding)#1{
    while ((ch = in.read()) > -1) {
      sb.append((char)ch);
    }
    in.close();
}


Instance 16

Class610.readUTF8FromFile(File file)#0{
    while ((ch = in.read()) > -1) {
      sb.append((char)ch);
    }
    in.close();
}


Instance 17

Class530.executeCommand(String command)#0{
        while ((read = reader.read(buffer)) > 0) {
          output.append(buffer, 0, read);
        }
        reader.close();
}


Instance 18

Class530.executeCommand(String command)#2{
        while ((read = reader2.read(buffer)) > 0) {
          output2.append(buffer, 0, read);
        }
        reader2.close();
}


Instance 19

Class400.read(BufferedReader inFile)#1{
      while ((len = inFile.read(buff)) >= 0)
        strb.append(buff, 0, len);
      inFile.close();
}


Instance 20

Class480.getStringFromFile(String path)#0{
            while ((numRead = reader.read(buf)) != -1) {
                String readData = String.valueOf(buf, 0, numRead);
                fileData.append(readData);
                buf = new char[1024];
            }
            reader.close();
}


Instance 21

Class180.processFile(String src,String dst)#0{
      while ((ch = in.read()) != -1)
        out.append((char)ch);
      out.append("\n"); //fix for the bug than .end method ends by EOF but not CRLF
      in.close();
}


Instance 22

Class120.showFileInfo(String filename)#0{
      while ((read = br.read(buffer)) > 0) {
        output.append(buffer, 0, read);
      }
      br.close();
}


Instance 23

Class600.deleteCacheDirectory(Context context)#2{
            while ((read = reader.read(buffer)) > 0) {
                output.append(buffer, 0, read);
            }
            reader.close();
}


Instance 24

Class240.getSchemaAsString(BufferedReader reader,int available)#0{
        StringBuffer sb = new StringBuffer(available);
            while( (numRead = reader.read(chars)) > -1){
                sb.append(String.valueOf(chars));
            }
            reader.close();
}


Instance 25

Class550.getFile(String url)#5{
        while ((read = in.read(str)) >= 0) {
            sw.write(str, 0, read);
            if (fw != null) {
                fw.write(str, 0, read);
            }
        }
        in.close();
}


Instance 26

Class510.gzips(String zipFileName,String mDestFile)#1{
        while ((c = in.read()) != -1) {

            out.write(String.valueOf((char) c).getBytes("UTF-8"));
        }
        in.close();
}


Instance 27

Class420.readIntoBuffer(BufferedReader br,StringBuffer buffer){
    while ((bytesRead = br.read(bytes)) > 0) {
      if (bytesRead == bufferSize) {
        buffer.append(bytes);
      }
      else {
        buffer.append(bytes, 0, bytesRead);
      }
    }
}


Instance 28

Class40.readJson()#2{
      while ((num = input.read(buffer)) > 0) {
        content.append(buffer, 0, num);
      }
      MyObject myobj = JsonHelper.parseGson(content.toString());
      if (myobj != null) {
        // Update ui
        if (jsonView != null)
          jsonView.setText(myobj.toString());
          Log.i(TAG,myobj.toString());
      }
}


Instance 29

Class280.getUrlContent(String urlAddress,Map requestProperties,Map requestParameters,String encoding,int timeout)#5{
      while ((i = buffer.read()) != -1)
        strbuf.append((char)i);
      String readData = strbuf.toString();   
}


Instance 30

Class170.decode()#1{
        while ((readLen = br.read(readBuf)) > 0) {
          tempMessage.append(readBuf, 0, readLen);
        }
        message = tempMessage.toString();
        if (message.startsWith("\n"))
          message = message.substring(1);
}


Instance 31

Class390.getLogContents(String logfile)#0{
    while((numRead = reader.read(buf)) !=-1) {
      String readData = String.valueOf(buf, 0,numRead);
      fileData.append(readData);
      buf = new char[1024];
    }
    return fileData.toString();
}


Instance 32

Class260.getResource(String name)#1{
        while ((i = br.read()) != -1) {
            sb.append((char) i);
        }
        return sb.toString();
}


Instance 33

Class170.readRawBytes(String fileName)#0{
    while ((c = in.read()) >= 0)
      buf.append((char) c);
    mRawBuffer = buf.toString();
}


Instance 34

Class60.loadTemplate()#0{
            while((c = reader.read()) != -1) {
                buffer.append((char)c);
            }
            template = buffer.toString();
}


Instance 35

Class380.readPackageList(InputStream input,String path,boolean relative)#0{
            while ((c = in.read()) >= 0) {
                char ch = (char)c;
                if (ch == '\n' || ch == '\r') {
                    if (strbuf.length() > 0) {
                        String packname = strbuf.toString();
                        String packpath = path +
                                      packname.replace('.', '/') + '/';
                        new Item(packname, packpath, relative);
                        strbuf.setLength(0);
                    }
                } else {
                    strbuf.append(ch);
                }
            }
            input.close();
}


Instance 36

Class660.testHappyPath()#3{
      while ((c = in.read()) != -1) {
        str.append((char) c);
      }
      String response = str.toString();
      assertEquals(sourceMessage, response);
}


Instance 37

Class650.getContent(DataSource ds)#0{
      while ((ch = is.read()) != -1)
        sb.append((char)ch);
      return sb.toString();
}


Instance 38

Class540.doGetReaderTest(String testString)#2{
        br = wrapper.getReader();
        while ((c = br.read()) != -1) {
            buff.append((char) c);
        }
        assertEquals(buff.toString(), testString);
}


Instance 39

Class120.getDataSet()#3{
    while ((c = is.read()) != -1) {
      txtStr.append((char) c);
    }
    newInst[0] = (double) data.attribute(0).addStringValue(txtStr.toString());
}


Instance 40

Class80.readBody(final BufferedReader r)#1{
    while (r.ready()) 
    {
      int charsRead = r.read(buffer);
      if (charsRead == -1) 
      {
        break;
      }
      b.append(buffer, 0, charsRead);
    }
    return b.toString();    
}


Instance 41

Class30.testOpenBufferedStream()#1{
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
}


Instance 42

Class440.readFrom(IInteger socketId)#0{
      while (in.ready()) {
        line.append((char)in.read());
      }
      return vf.string(line.toString());
}


Instance 43

Class410.transferData(Reader source,Writer dest,int tz)#0{
        BufferedWriter out = new BufferedWriter(dest, tz);
        while ((read = in.read(bridge, 0, tz)) != -1) {
            out.write(bridge, 0, read);
            total += read;
        }
        in.close();
}


Instance 44

Class590.readUrl(String urlString)#3{
        while ((read = reader.read(chars)) != -1)
            buffer.append(chars, 0, read); 
        return buffer.toString();
}


Instance 45

Class430.ReadProcessOutput(BufferedReader stdInput)#0{
        while ((bytesRead = stdInput.read(readBuf)) > 0) {
            r.append(readBuf, 0, bytesRead);
        }
        return r.toString();
}


Instance 46

Class160.inputStreamToString(final InputStream in)#2{
      while ((reader.read(buffer)) != -1) {
        buf.append(buffer);
      }
      return buf.toString();
}


Instance 47

Class270.readUrl(String urlString,String userAgent,String accept,String cookies)#0{
          while ((read = reader.read(chars)) != -1)
              buffer.append(chars, 0, read); 
          return buffer.toString();
}


Instance 48

Class560.testOpenBufferedStream()#1{
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
}


Instance 49

Class110.InputStreamToString(InputStream in)#0{
            while ((charOut = reader.read()) != -1) {
                myStrBuf.append(String.valueOf((char) charOut));
            }
}


Instance 50

Class280.doInBackground(Void... arg0)#3{
          File file = new File(path.toString());
          if(!file.canRead()){
            /*
             * READS THE FILE UNDER PROTECTED DIRECTORY...SYSTEM FILES WITH NO READ PERMISSION
             */
            BufferedReader re = LinuxShell.execute("cat "+file.getPath());
            while((read = re.read(buffer,0,1000))!=-1)
              rea.append(buffer,0,read);
            re.close();
            openFile(path, rea);
            return null;
          }
          FileReader reader = new FileReader(new File(path.toString()));
}


Instance 51

Class110.InputStreamToString(InputStream in)#2{
            while ((charOut = reader.read()) != -1) {
                myStrBuf.append(String.valueOf((char) charOut));
            }
}


Instance 52

Class280.getPayloadAsString(final HttpServletRequest request)#0{
    int b = reader.read( buffer );
    while ( b > 0 ) {
      stringBuffer.append( buffer, 0, b );
    }
    return stringBuffer.toString();
}


Instance 53

Class290.getText(String filename,Class source)#2{
            while ((nb = reader.read(buffer, 0, 1024)) >= 0) {
                res.append(buffer, 0, nb);
            }
            return res.toString();
}


Instance 54

Class120.extractMessageContents(Message m)#5{
        while ((c = reader.read(ch)) != -1) {
          sb.append(ch, 0, c);
        }
        this.messageContents = sb.toString();
}


Instance 55

Class80.getJSONObject(URL jsonURL)#0{
    while((read = reader.read(buff)) > 0) {
      buffer.append(buff, 0, read);
    }
    DynamicCloudsDaemon.LOG.info("Read " + buffer.length() + " bytes");
    Object res = JSON.parse(buffer.toString());
}


Instance 56

Class150.transferData(Reader src,Writer dest,long charsToCopy)#0{
        BufferedWriter out = new BufferedWriter(dest, BUFFER_SIZE);
        while ((read = in.read(bridge, 0, (int)Math.min(charsLeft, BUFFER_SIZE))) > 0) {
            out.write(bridge, 0, read);
            charsLeft -= read;
        }
        in.close();
}


Instance 57

Class460.readXMLFile(String filePath)#3{
    while ((n = bufferReader.read(buf)) > 0) {
      w.write(buf, 0, n);
    }
    bufferReader.close();
}


Instance 58

Class40.streamToString(InputStream in)#0{
            while ((len = reader.read(buffer)) > 0) {
                sb.append(buffer, 0, len);
            }
}


Instance 59

Class220.main(String[] args)#1{
            while ((charsRead = r.read(cbuf, 0, 10240)) != -1) 
                sb.append(cbuf, 0, charsRead);
}


Instance 60

Class10.loadFile(File file)#1{
            while ((read = br.read(buffer)) != -1) {
                str.append(buffer, 0, read);
            }
            fr.close();
}


Instance 61

Class300.getFileContents(IFile file)#0{
    while ((read= reader.read(part)) != -1)
      buffer.append(part, 0, read);
    reader.close();
}


Instance 62

Class330.readContent(InputStream input)#1{
      while ((charsRead = reader.read(charBuff)) > -1) {
        strBuff.append(charBuff, 0, charsRead);
      }
      reader.close();
}


Instance 63

Class230.fileToString(FileSystem fs,Path path)#1{
    while((read = br.read(buff)) != -1) {
      sb.append(buff, 0, read);
    }
    br.close();
}


Instance 64

Class150.runDiff()#2{
        while (reader.read(part) != -1) {
            sbExpDiff.append(part);
        }
        reader.close();
}


Instance 65

Class630.compressFileToGzip(String inFilename)#2{
            while ((c = in.read()) != -1) {
                out.write(c);
            }
            in.close();
}


Instance 66

Class290.unGZipBytes(byte[] bytes)#1{
      while((c = br.read()) != -1) {
        baos.write(c);
      }
      br.close();
}


Instance 67

Class560.getEntireResponse(final BufferedReader in)#0{
            while ((chars = in.read(cbuf, 0, 1024)) != -1) {
                response.append(cbuf, 0, chars);
            }
}


Instance 68

Class390.getValue()#1{
            while ((len = r.read(buf)) != -1) {
                b.append(buf, 0, len);
            }
            r.close();
}


Instance 69

Class420.initTemplateContentsFromInputStream(InputStream templateStream)#1{
        StringBuilder builder = new StringBuilder(BUFFER_SIZE);
            while ((nRead = reader.read(cbuf, 0, BUFFER_SIZE)) > 0) {
                builder.append(cbuf, 0, nRead);
            }
            reader.close();
}


Instance 70

Class460.getFileContent(String fileName)#4{
    while ((read = in.read(buffer)) >= 0) {
      sb.append(buffer, 0, read);
    }
    in.close();
}


Instance 71

Class230.readFileAsString(File file)#0{
            while((numRead=reader.read(buf)) != -1){
                fileData.append(buf, 0, numRead);
            }
            reader.close();
}


Instance 72

Class130.zipCompress(String filename)#4{
    while ((c = in.read()) != -1)
      out.write(c);
    in.close();
}


Instance 73

Class330.createCharSequence(Reader reader0)#0{
      while((chars = reader.read(buff)) != -1) {
        result.write(buff, 0, chars);
      }
      reader.close();
}


Instance 74

Class240.main(String[] args)#1{
        while ((n = in.read(buf)) != -1) {
            out.write(buf, 0, n);
            System.err.print(" " + n);
        }
        in.close();
}


Instance 75

Class0.copyStreamToString(InputStream input,int approxStringLength)#0{
    while ((charsRead = reader.read(buffer)) != -1) {
      w.write(buffer, 0, charsRead);
    }
    return w.toString();
}


Instance 76

Class30.getFileFromPackage(String filename)#1{
                while ((c = in.read()) > -1) {
                    s.write(c);
                }
                return s.toString();
}


Instance 77

Class600.loadContents(@Nonnull File file,@Nonnull Charset charset)#2{
      while ((c = reader.read()) != -1) {
        writer.write(c);
      }
      return checkNotNull(writer.toString());
      closeQuietly(reader);
}


Instance 78

Class380.getContents(File root,String file)#2{
    while ((read = br.read(buffer)) != -1) {
      capture.write(buffer, 0, read);
    }
    return capture.toString();
}


Instance 79

Class420.readResource(URL resourceUrl)#4{
      while ((iRead = resourceBr.read(buffer)) != -1) {
        sw.write(buffer, 0, iRead);
      }
      result = sw.toString();
}


Instance 80

Class260.loadContents(File file,Charset charset)#2{
      while ((c = reader.read()) != -1) {
        writer.write(c);
      }
      return writer.toString();
}


Instance 81

Class630.loadContents(InputStream stream,Charset charset)#0{
      while ((c = reader.read()) != -1) {
        writer.write(c);
      }
      return writer.toString();
}


Instance 82

Class190.convertFileFromUtf16ToUtf8(File inputFile,File outputFile)#2{
        while ((c = reader.read()) != -1) {
          writer.write(c);
        }
        writer.close();
}


Instance 83

Class390.generateUTF8OutFile(File FinalOutFile)#0{
          while ((c = inFile.read()) != -1)
            bw.write(c);
          bw.flush();
          bw.close();
}


Instance 84

Class30.writeInputStreamToFile(String fileName,BufferedReader bufferedReader)#1{
      while ((len = bufferedReader.read(buf)) > 0)
        out.write(buf, 0, len);
      out.close();
}


Instance 85

Class500.visitFile(AstNode astNode){
      BufferedReader reader = Files.newReader(getContext().getFile(), charset);
      while ((c = reader.read()) != -1) {

        if (c == '\r' || c == '\u2028' || c == '\u2029') {
          getContext().createFileViolation(this, "Replace all non line feed end of line characters in this file \"{0}\" by LF.",
            getContext().getFile().getName());
          break;
        }
      }
      LOG.error("Unable to process check S1779 on file: {}", getContext().getFile().getName(), e);
}


Instance 86

Class90.getLineNumber(File file,String encoding)#4{
      while ((ch = bis.read()) != -1) {
        if (ch == '\r' || ch == '\n') {
          if (!isline) {
            isline = true;
            count++;
          }
        } else {
          isline = false;
        }
      }
}


Instance 87

Class240.process(Reader unbufferedReader)#4{
      while ((length = bufferedReader.read(content)) > -1) {
        processEvents(decoderInstance.decodeEvents(String.valueOf(content,
            0, length)));
      }
}


Instance 88

Class590.process(Reader unbufferedReader)#3{
            while ((length = bufferedReader.read(content)) > -1) {
                processEvents(decoderInstance.decodeEvents(String.valueOf(content, 0, length)));
            }
}


Instance 89

Class620.execute()#5{
            while ((n = reader.read(buf)) > 0) {
                w.write(buf, 0, n);
            }
}


Instance 90

Class360.main(String[] args)#7{
            while(bufInputReader.read(array) != -1) {
                charArrayWriter.write(array); 
            }
       
}


Instance 91

Class650.addStringToZip(String text,String entryName,ZipOutputStream zOut)#2{
    while((i = reader.read()) != -1) {
      zOut.write(i);
    }
    zOut.closeEntry();
}


Instance 92

Class530.copyFiles(File outDir,String suppFiles)#1{
                    while ((c = inFile.read()) != -1)
                        pw.write(c);
                    pw.flush();
                    pw.close();
}


Instance 93

Class410.parseAwfulCSV(BufferedReader reader,boolean header)#10{
    while ((ch = reader.read()) != -1) {
      if (insideQuote) {
        if (ch == '\"') {
          // this is either the end of a quoted entry, or a quote character
          reader.mark(1);
          if (reader.read() == '\"') {
            // it's "", which means a quote character
            if (count == c.length) {
              c = PApplet.expand(c);
            }
            c[count++] = '\"';
          } else {
            // nope, just the end of a quoted csv entry
            reader.reset();
            insideQuote = false;
            // TODO nothing here that prevents bad csv data from showing up
            // after the quote and before the comma...
//            set(row, col, new String(c, 0, count));
//            count = 0;
//            col++;
//            insideQuote = false;
          }
        } else {  // inside a quote, but the character isn't a quote
          if (count == c.length) {
            c = PApplet.expand(c);
          }
          c[count++] = (char) ch;
        }
      } else {  // not inside a quote
        if (ch == '\"') {
          insideQuote = true;

        } else if (ch == '\r' || ch == '\n') {
          if (ch == '\r') {
            // check to see if next is a '\n'
            reader.mark(1);
            if (reader.read() != '\n') {
              reader.reset();
            }
          }
          setString(row, col, new String(c, 0, count));
          count = 0;
          if (row == 0 && header) {
            // Use internal row removal (efficient because only one row).
            removeTitleRow();
            // Un-set the header variable so that next time around, we don't
            // just get stuck into a loop, removing the 0th row repeatedly.
            header = false;
          }
          row++;
          col = 0;

        } else if (ch == ',') {
          setString(row, col, new String(c, 0, count));
          count = 0;
          // starting a new column, make sure we have room
          col++;
          ensureColumn(col);

        } else {  // just a regular character, add it
          if (count == c.length) {
            c = PApplet.expand(c);
          }
          c[count++] = (char) ch;
        }
      }
    }
}


Instance 94

Class370.run()#4{
            while((read = br.read(buff)) != -1) {

                SessionOutputUtil.addToOutput(sessionOutput.getSessionId(), sessionOutput.getInstanceId(), buff,0,read);
                Thread.sleep(50);
            }
}


Instance 95

Class30.parseExecResult(BufferedReader lines)#1{
      while ( (nRead = lines.read(buf, 0, buf.length)) > 0 ) {
        output.append(buf, 0, nRead);
      }
}


Instance 96

Class180.loadData(Cache<String,String> cache)#0{
            CharBuffer cbuf = CharBuffer.allocate(1024 * chunkSize);
            while (bufferedReader.read(cbuf) >= 0) {
                Buffer buffer = cbuf.flip();
                String textChunk = buffer.toString();
                cache.put(textFileName + (chunkId++), textChunk);
                cbuf.clear();
                if (chunkId % 100 == 0)
                    System.out.printf("  Inserted %s chunks from %s into grid%n", chunkId, textFileName);
            }
}


Instance 97

Class280.GetPage(URL url,RequestSettings settings)#0{
      while((r = in.read()) != -1){
        out.write(r);
      }
        out.close();
}


Instance 98

Class600.SqlFileBuilder(BufferedReader reader)#1{
            while (-1 != (c = reader.read())) {
                stack.eat(c);
            }
}


Instance 99

Class350.testFetchLargeClobOneByOneCharBaseline()#1{
            while (bufferedContent.read() != -1) {
                remaining--;
            }
            content.close();
}


Instance 100

Class660.handlePut(final HttpServletRequest request,final ServletResponse response)#1{
    while ((i = reader.read()) != -1) {
      out.write(i);
    }
    out.close();
}


Instance 101

Class50.readerLoop()#0{
    while (!this.isStopping && read != -1) {
      read= bufferedInput.read();
    }
}


Instance 102

Class500.parse(InputStream in)#0{
        while ((len = reader.read(mReadBuf)) != -1) {
            mStringBuf.append(mReadBuf, 0, len);
        }
}


Instance 103

Class610.getLineOffset(int lineNumber,IFile file)#3{
      while ((lineCount < lineNumber - 1) && (ch != -1)) {
        try {
          ch = in.read();
        } catch (IOException e1) {
          OcamlPlugin.logError("Error in 2 OcamlBuilder:getLineOffset()", e1);
        }
        if (ch != -1) {
          charCount++;
          if (ch == '\n') {
            lineCount++;
          }
        }
      }
}


Instance 104

Class200.fetch(BufferedReader reader)#1{
    while (actual != -1) {
      writer.write(baf, 0, actual);
      actual = reader.read(baf, 0, BUFFER_SIZE);
    }
}